package com.fdb.efp.nls.service.impl.sx;

import static java.util.stream.Collectors.groupingBy;

import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.Optional;
import java.util.function.Function;
import java.util.function.IntPredicate;
import java.util.function.Predicate;
import java.util.stream.Collectors;
import java.util.stream.Stream;

import com.fdb.efp.nls.service.facade.NlsApplyInfoService;
import com.fdb.efp.nls.service.facade.queue.NlsProcessBizService;
import com.fdb.efp.nls.service.facade.queue.NlsProcessRuleService;
import com.fdb.efp.nls.service.vo.queue.NlsProcessBizVO;
import com.fdb.efp.nls.service.vo.queue.NlsProcessRuleVO;
import com.fdb.efp.nls.service.vo.sx.NlsCreditInfoVO;
import org.apache.commons.lang.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Service;

import com.fdb.basic.framework.core.exception.BizException;
import com.fdb.basic.framework.core.util.DateTool;
import com.fdb.basic.framework.core.util.DateUtility;
import com.fdb.basic.framework.core.util.TimeUtil;
import com.fdb.cdp.pboc.service.facade.PbocBadDebtsService;
import com.fdb.cdp.pboc.service.facade.PbocCreditBasicService;
import com.fdb.cdp.pboc.service.facade.PbocCreditStatusService;
import com.fdb.cdp.pboc.service.facade.PbocCreditquerySummaryService;
import com.fdb.cdp.pboc.service.facade.PbocLoadBasicService;
import com.fdb.cdp.pboc.service.facade.PbocLoadStatusService;
import com.fdb.cdp.pboc.service.facade.PbocNearcreditStatusService;
import com.fdb.cdp.pboc.service.facade.QueryReportService;
import com.fdb.cdp.pboc.service.facade.ZXHtmlInfoService;
import com.fdb.cdp.pboc.service.vo.PbocBadDebtsVO;
import com.fdb.cdp.pboc.service.vo.PbocCreditBasicVO;
import com.fdb.cdp.pboc.service.vo.PbocCreditStatusVO;
import com.fdb.cdp.pboc.service.vo.PbocCreditquerySummaryVO;
import com.fdb.cdp.pboc.service.vo.PbocLoadBasicVO;
import com.fdb.cdp.pboc.service.vo.PbocLoadStatusVO;
import com.fdb.cdp.pboc.service.vo.PbocNearcreditStatusVO;
import com.fdb.cdp.pboc.service.vo.QueryReportVO;
import com.fdb.cdp.pboc.service.vo.ZXHtmlInfoVO;
import com.fdb.efp.nls.service.facade.PrdInfoService;
import com.fdb.efp.nls.service.facade.PrdSoltRuleService;
import com.fdb.efp.nls.service.vo.PrdInfoVO;
import com.fdb.efp.nls.service.vo.PrdSoltRuleVO;
import com.fdb.efp.esb.common.constant.MsLoanConstant;
import com.fdb.efp.esb.common.constant.ZXReturnType;
import com.fdb.efp.esb.service.bo.req.ZX10001QueryReports;
import com.fdb.efp.esb.service.facade.zx.ZXService;
import com.fdb.efp.esb.service.vo.zx.ZXVO;
import com.fdb.efp.nls.common.constant.PrdAdaptedSoltEnums;
import com.fdb.efp.rule.common.enumeration.Rule;
import com.fdb.efp.rule.service.facade.RuleCallService;
import com.fdb.efp.rule.service.vo.ReqCreditRuleVo;
import com.fdb.efp.rule.service.vo.ReqRuleVo;
import com.fdb.efp.rule.service.vo.RespRuleVO;

/**
 * 授信申请征信规则服务
  * @author heyingfeng
  * @since 2019年3月12日 上午10:16:03
  * @version 1.0
 */
@Service("creditZXRuleService")
public class CreditZXRuleServiceImpl extends CreditSoltServiceImpl {

	private static final Logger log = LoggerFactory.getLogger(CreditZXRuleServiceImpl.class);
	private static final String zxRule = "CcrcRule";

	@Override
	public void doExecute(NlsProcessBizVO nlsProcessBizVo, NlsCreditInfoVO nlsCreditInfoVO) throws Exception {
		String applySeq = nlsProcessBizVo.getApplySeq();
		String slotCode = nlsProcessBizVo.getSoltCode();

		try {
			/** 查询申请信息，获得征信查询接口所需的参数 **/
			String appNo = applySeq;
			log.info("开始进行征信规则参数准备,流水号:" + appNo);
			Objects.requireNonNull(nlsCreditInfoVO);
			String cusName = nlsCreditInfoVO.getCusName();
			String certNo = nlsCreditInfoVO.getCertCode();
			String authCd = appNo;
			String bussinessType = nlsCreditInfoVO.getPrdCode(); // 产品编号
			String authDate = nlsCreditInfoVO.getApplyDate();

			/** 查询规则过程表信息 */
			NlsProcessRuleVO nlsProcessRuleVO = new NlsProcessRuleVO();
			nlsProcessRuleVO.setApplySeq(applySeq);
			nlsProcessRuleVO = nlsProcessRuleService.queryByPk(nlsProcessRuleVO);
			/** 添加要执行的规则 */
			List<PrdSoltRuleVO> prdSoltRules = prdSoltRuleService.queryByPrdIdAndSoltCode(nlsCreditInfoVO.getPrdCode(), slotCode);

			/** 查询产品获取征信userId */
			String prdId = Objects.requireNonNull(nlsCreditInfoVO.getPrdId());
			PrdInfoVO prdInfoVo = new PrdInfoVO();
			prdInfoVo.setPrdId(prdId);
			prdInfoVo = prdInfoService.queryByPk(prdInfoVo);
			
			/** 调用征信查询接口并落库 **/
			final String queryType = "2", queryReason = "02";
			ZX10001QueryReports zxJSONQueryReports = new ZX10001QueryReports.Builder().withCustNm(cusName).withCertNo(certNo).withQryTp(queryType) // 查询类型 - 信用报告(带数字解读)
					.withQryRsn(queryReason) // 查询原因
					.withRtnType(ZXReturnType.JSON.VALUE).withAuthCd(authCd).withBizType(bussinessType).withAuthTm(authDate).build();
			ZX10001QueryReports zxHTMLQueryReports = new ZX10001QueryReports.Builder().withCustNm(cusName).withCertNo(certNo).withAuthCd(authCd).withBizType(bussinessType).withQryRsn(queryReason)
					.withQryTp(queryType).withAuthTm(authDate).withRtnType(ZXReturnType.HTML.VALUE).build();
			String reportId = null;
			
			QueryReportVO queryReportVo = new QueryReportVO();
			queryReportVo.setCercode(certNo);
			List<QueryReportVO> queryReports = queryReportService.queryReportId(queryReportVo);
			if(queryReports.size()>0) {//有征信数据
				String reportTime = queryReports.get(0).getReportTime();//最新征信报告时间
				reportTime = StringUtils.replace(reportTime, ".", "-");//转换yyyy-MM-dd HH:mm:ss
				int day = TimeUtil.compareDates(reportTime,DateTool.getCurrentDateTime());
				if(day < 0) {//报告时间小于当前时间，调用征信接口
					try {
						ZXVO zxvoJson = zxJSONService.service(zxJSONQueryReports,prdInfoVo.getZxOpId());
						ZXVO zxvoHtml = zxHTMLService.service(zxHTMLQueryReports,prdInfoVo.getZxOpId()); // 调用征信HTML接口
						reportId = (String) zxvoJson.getResp(); // not null
						ZXHtmlInfoVO zxHtmlInfoVO = (ZXHtmlInfoVO) zxvoHtml.getResp();
						zxHtmlInfoVO.setReportId(reportId);
						zxHtmlInfoService.insert(zxHtmlInfoVO);
					} catch (Exception e) {
						throw new BizException("调用征信系统异常", e);
					}
					log.info("征信单笔查询接口调用完成,流水号:" + appNo + "，报告编号：" + reportId);
				}else {//大于当前时间，不进行落库
					reportId = queryReports.get(0).getReportId();
					log.info("征信报告时间未到，不查询征信:" + appNo + "，报告编号：" + reportId);
				}
			}else {//无征信报告，调用征信接口
				try {
					ZXVO zxvoJson = zxJSONService.service(zxJSONQueryReports,prdInfoVo.getZxOpId());
					ZXVO zxvoHtml = zxHTMLService.service(zxHTMLQueryReports,prdInfoVo.getZxOpId()); // 调用征信HTML接口
					reportId = (String) zxvoJson.getResp(); // not null
					ZXHtmlInfoVO zxHtmlInfoVO = (ZXHtmlInfoVO) zxvoHtml.getResp();
					zxHtmlInfoVO.setReportId(reportId);
					zxHtmlInfoService.insert(zxHtmlInfoVO);
				} catch (Exception e) {
					throw new BizException("调用征信系统异常", e);
				}
				log.info("征信单笔查询接口调用完成,流水号:" + appNo + "，报告编号：" + reportId);
			}
			/** 获取规则参数 **/
			final String typeCredit = "CRDT", // 贷记卡
					typeNearCredit = "NECT", // 准贷记卡
					zero = "0"; // 表示0的字符串，用于规则参数的默认值
			// 贷款当前状态为“逾期”的总数
			PbocLoadBasicVO pbocLoadBasicVO = new PbocLoadBasicVO();
			pbocLoadBasicVO.setFId(reportId);
			List<PbocLoadBasicVO> reportLoadBasics = Optional.ofNullable(pbocLoadBasicService.selectByReportId(pbocLoadBasicVO)).orElseGet(ArrayList::new);
			List<String> fids = reportLoadBasics.stream().map(PbocLoadBasicVO::getPId).collect(Collectors.toList());
			List<PbocLoadStatusVO> loadStatusList = 
					Optional.ofNullable(pbocLoadStatusService.queryByFId(fids)).orElseGet(ArrayList::new);
			int overdueNums = 
					loadStatusList.stream().map(PbocLoadStatusVO::getLoadStatus)
					.filter(Objects::nonNull).filter(t -> t.equals("逾期"))
					.mapToInt(e -> 1).sum();
			if (log.isDebugEnabled())
				log.debug("征信规则参数准备，贷款当前状态为“逾期”的总数为： " + overdueNums);
			// 统计当前状态为“逾期”、“呆账”、“冻结”、“止付”等特殊情况的贷记卡和准贷记卡数目
			PbocCreditBasicVO pbocCreditBasicVO = new PbocCreditBasicVO();
			pbocCreditBasicVO.setFId(reportId);
			List<PbocCreditBasicVO> creditBasics = Optional.ofNullable(pbocCreditBasicService.selectByReportId(pbocCreditBasicVO)).orElseGet(ArrayList::new);
			Map<String, List<PbocCreditBasicVO>> creditMap = creditBasics.stream().collect(groupingBy(PbocCreditBasicVO::getCreditType));//
			// 根据卡的类型进行分组
			fids = Optional.ofNullable(creditMap.get(typeCredit))
						.map(i -> i.stream().map(PbocCreditBasicVO::getPId).collect(Collectors.toList()))
						.orElseGet(ArrayList::new);
			int ccAbnormalNum = Optional.ofNullable(pbocCreditStatusService.selectByFIdS(fids))
					.map(creditFunc).orElse(0);// 贷记卡
			fids = Optional.ofNullable(creditMap.get(typeNearCredit))
					.map(i -> i.stream().map(PbocCreditBasicVO::getPId).collect(Collectors.toList()))
					.orElseGet(ArrayList::new);
			List<PbocNearcreditStatusVO> nearcreditStatusList = Optional.ofNullable(pbocNearcreditStatusService.queryByFID(fids)).orElseGet(ArrayList::new);
			int sccAbnormalNum = nearCreditFunc.apply(nearcreditStatusList);// 准贷记卡
			if (log.isDebugEnabled())
				log.debug("当前状态为“逾期”、“呆账”、“冻结”、“止付”的贷记卡数目为： " + ccAbnormalNum);
			if (log.isDebugEnabled())
				log.debug("当前状态为“逾期”、“呆账”、“冻结”、“止付”的准贷记卡数目为： " + sccAbnormalNum);
			// 统计是否最近12个月连续M次（含）以上逾期记录
			int loanOverdue12MContNum = 0;
			for (PbocLoadBasicVO reportLoad : reportLoadBasics) {
				if (reportLoad.getMonth24status() == null)
					continue;
				for (char c : last12MonthStatus.apply(reportLoad.getMonth24status()).toCharArray()) {
					if (ifOverdueStatus.test(c)) {
						loanOverdue12MContNum = 
								Math.max(loanOverdue12MContNum, Integer.valueOf(String.valueOf(c)));
					}
				}
			}
			if (log.isDebugEnabled())
				log.debug("贷款最近12个月连续逾期记录： " + loanOverdue12MContNum);
			// 贷款最近12个月内有累计超过M次（含）逾期记录（单笔贷款）
//			int loanOverdue12MTotalNum = reportLoadBasics.stream().map(PbocLoadBasicVO::getMonth24status).filter(Objects::nonNull).map(last12MonthStatus)
//					.mapToInt(i -> i.chars().filter(ifOverdueStatus).map(e -> 1).sum()).max().orElse(0);
//			if (log.isDebugEnabled())
//				log.debug("贷款最近12个月内有累计逾期记录: " + loanOverdue12MTotalNum);
			// 贷记卡、准贷记卡最近12个月内有连续3次（含）以上逾期记录（单张贷记卡、准贷记卡）
			int ccOverdue12MContNum = 0;
			for (PbocCreditBasicVO pBasicVO : creditBasics) {
				if (pBasicVO.getMonth24status() == null)
					continue;
				for (char c : last12MonthStatus.apply(pBasicVO.getMonth24status()).toCharArray()) {
					if (ifOverdueStatus.test(c)) {
						ccOverdue12MContNum = 
								Math.max(ccOverdue12MContNum, Integer.valueOf(String.valueOf(c)));
					}
				}
			}
			if (log.isDebugEnabled())
				log.debug("贷记卡、准贷记卡最近12个月内连续逾期记录: " + ccOverdue12MContNum);
			// 贷记卡、准贷记卡最近12个月内有M次（含）以上逾期记录（单张贷记卡、准贷记卡）
			int ccOverdue12MTotalNum = creditBasics.stream().map(PbocCreditBasicVO::getMonth24status).filter(Objects::nonNull).map(last12MonthStatus)
					.mapToInt(i -> i.chars().filter(ifOverdueStatus).map(e -> 1).sum()).max().orElse(0);
			if (log.isDebugEnabled())
				log.debug("贷记卡、准贷记卡最近12个月内累计逾期记录： " + ccOverdue12MTotalNum);
			// 统计出贷款出现“呆账”、“资产处置”、“保证人代偿”等特殊情况的记录数
			PbocBadDebtsVO pbocBadDebtsVo = new PbocBadDebtsVO();
			pbocBadDebtsVo.setFId(reportId);
			PbocBadDebtsVO reportBadDebts = Optional.ofNullable(pbocBadDebtsService.selectByReportId(pbocBadDebtsVo)).orElseGet(PbocBadDebtsVO::new);
			int loanSpecNum = Stream.of(reportBadDebts.getAssetsNum(), reportBadDebts.getBadDebtsNum(), reportBadDebts.getSponsorialNum()).map(Optional::ofNullable)
					.map(i -> i.map(Integer::valueOf).orElse(0)).reduce(Integer::sum).get();
			if (log.isDebugEnabled())
				log.debug("贷款出现“呆账”、“资产处置”、“保证人代偿”等特殊情况的记录数: " + loanSpecNum);
			// 统计出贷款五级分类状态为“次级”、“可疑”、“损失”（所有贷款）的记录数
			fids = reportLoadBasics.stream().map(PbocLoadBasicVO::getPId).collect(Collectors.toList());
			int loan5CcAbnormalNum = loadStatusList.stream().map(PbocLoadStatusVO::getFiveStyle).filter(ifFiveStyle).mapToInt(e -> 1).sum();
			if (log.isDebugEnabled())
				log.debug("贷款五级分类为“次级”、“可疑”、“损失”（所有贷款）的记录数: " + loan5CcAbnormalNum);
			// 统计出准贷记卡有透支180天以上未还款记录（所有准贷记卡）
//			fids = Optional.ofNullable(creditMap.get(typeNearCredit)).orElseGet(ArrayList::new).stream().map(PbocCreditBasicVO::getPId).collect(Collectors.toList());
//			int sccOverdue180DNum = nearcreditStatusList.stream().map(PbocNearcreditStatusVO::getOverdue180dAmount).filter(Objects::nonNull).map(i -> new BigDecimal(i))
//					.filter(i -> i.compareTo(BigDecimal.ZERO) > 0).mapToInt(e -> 1).sum();
//			if (log.isDebugEnabled())
//				log.debug("准贷记卡有透支180天以上未还款记录: " + sccOverdue180DNum);
			// 统计出近1个月查询次数（贷款申请+信用卡申请）
			PbocCreditquerySummaryVO querySum = Optional.ofNullable(PbocCreditquerySummaryService.queryByFId(reportId)).orElseGet(PbocCreditquerySummaryVO::new);
			int creditQueryNum = Integer.valueOf(Optional.ofNullable(querySum.getLoadQueryTimes()).orElse(zero)) + Integer.valueOf(Optional.ofNullable(querySum.getCreditQueryTimes()).orElse(zero));
			if (log.isDebugEnabled())
				log.debug("近1个月查询次数: " + creditQueryNum);

			/** 执行规则 **/ 
			ReqRuleVo reqRuleVo = new ReqRuleVo();
			reqRuleVo.setAppNo(appNo);
			reqRuleVo.setPrdCode(nlsCreditInfoVO.getPrdCode());
			ReqCreditRuleVo param = new ReqCreditRuleVo();
			param.setCcAbnormalNum(ccAbnormalNum);
			param.setCcOverdue12MContNum(ccOverdue12MContNum);
			param.setCcOverdue12MTotalNum(ccOverdue12MTotalNum);
			param.setCreditQueryNum(creditQueryNum);
			param.setLoan5CcAbnormalNum(loan5CcAbnormalNum);
			param.setLoanOverdue12MContNum(loanOverdue12MContNum);
//			param.setLoanOverdue12MTotalNum(loanOverdue12MTotalNum);
			param.setLoanSpecNum(loanSpecNum);
			param.setOverdueNum(overdueNums);
			param.setSccAbnormalNum(sccAbnormalNum);
//			param.setSccOverdue180DNum(sccOverdue180DNum);
			reqRuleVo.setReqCreditRuleVo(param);

			/** 批量执行规则 **/
			List<RespRuleVO> list = ruleService.executeBatchRule(Rule.RuleType.ZX, reqRuleVo);
			/** 规则结果分组 **/
			Map<String, List<RespRuleVO>> map = list.stream().collect(Collectors.groupingBy(RespRuleVO::getRuleId));
			/** 规则结果信息  记录拒绝原因细类*/
			StringBuilder sb = new StringBuilder();
			for (int j = 0; j < prdSoltRules.size(); j++) {
				String order = prdSoltRules.get(j).getRuleOrder();
				/** 规则名称method映射 */
				Method methodRuleName = NlsProcessRuleVO.class.getMethod("setRuleName" + order, String.class);
				/** 规则状态method映射 */
				Method methodRuleState = NlsProcessRuleVO.class.getMethod("setRuleState" + order, String.class);
				/** 规则时间method映射 */
				Method methodRuleTime = NlsProcessRuleVO.class.getMethod("setRuleTime" + order, String.class);

				methodRuleName.invoke(nlsProcessRuleVO, prdSoltRules.get(j).getRuleCode());
				methodRuleTime.invoke(nlsProcessRuleVO, DateUtility.getCurrAppDateTimeString());
				if (map.get(prdSoltRules.get(j).getRuleCode()) != null) {
					methodRuleState.invoke(nlsProcessRuleVO, PrdAdaptedSoltEnums.SoltProcessStateEnum.FAILURE.getCode());
					sb.append(prdSoltRules.get(j).getRuleName()).append("规则不通过;");
					/**根据规则id映射返回开放平台错误信息**/
//					reasonCode = MsLoanConstant.ReasonCodeMap.get(prdSoltRules.get(j).getRuleCode());
//					refuseMsg = MsLoanConstant.ReasonMsgMap.get(prdSoltRules.get(j).getRuleCode());
					break;
				} else {
					methodRuleState.invoke(nlsProcessRuleVO, PrdAdaptedSoltEnums.SoltProcessStateEnum.SUCCESS.getCode());
				}
			}
			/** 插入规则过程表 */
			nlsProcessRuleService.updateByPk(nlsProcessRuleVO);
			/**设置百度原因说明**/
//			nlsCreditInfoVO.setBdReasonCode(reasonCode);
//			nlsCreditInfoVO.setBdReasonMsg(refuseMsg);

			if (!list.isEmpty()) {
				throw new BizException(sb.toString());
			}
		} catch (Exception e) {
			log.error(Arrays.toString(e.getStackTrace()));
			/**设置百度原因说明**/
			nlsCreditInfoVO.setBdReasonCode(MsLoanConstant.ReasonCodeMap.get(zxRule));
			nlsCreditInfoVO.setBdReasonMsg(MsLoanConstant.ReasonMsgMap.get(zxRule));
			nlsProcessBizVo.setExceptionFlag(true);
			nlsProcessBizVo.setExceptionMsg(e);
		}
	}

	// private static final Predicate<String> creditStat =
	// OVERDUE.or(BADDEBT).or(FREEZE).or(STOPPAY);
	private static final Function<List<PbocCreditStatusVO>, Integer> creditFunc = 
			list -> list.stream().map(i -> Optional.ofNullable(i.getCreditStatus()).orElseGet(String::new)).filter(t -> {
				return t.equals("逾期") || t.equals("呆账") || t.equals("冻结") || t.equals("止付");
			}).mapToInt(e -> 1).sum();
	private static final Function<List<PbocNearcreditStatusVO>, Integer> nearCreditFunc = 
			list -> list.stream().map(i -> Optional.ofNullable(i.getNearcreditStatus()).orElseGet(String::new)).filter(t -> {
				return t.equals("逾期") || t.equals("呆账") || t.equals("冻结") || t.equals("止付");
			}).mapToInt(e -> 1).sum();
	private static final IntPredicate ifOverdueStatus = c -> c >= '1' && c <= '7';
	private static final Predicate<String> ifFiveStyle = s -> s.equals("次级") || s.equals("可疑") || s.equals("损失");
	private static final Function<String, String> last12MonthStatus = i -> i.length() >= 12 ? i.substring(i.length() - 12) : i;

	// enum CreditStatus implements java.util.function.Predicate<String> {
	// OVERDUE { public boolean test(String t) { return t.equals("逾期"); } },
	// BADDEBT { public boolean test(String t) { return t.equals("呆账"); } },
	// FREEZE { public boolean test(String t) { return t.equals("冻结"); } },
	// STOPPAY { public boolean test(String t) { return t.equals("止付"); } };
	// }

	@Autowired
	@Qualifier("nlsApplyInfoService")
	private NlsApplyInfoService nlsApplyInfoService;
	@Autowired
	@Qualifier("zx10001JSONService")
	private ZXService<ZX10001QueryReports> zxJSONService;
	@Autowired
	@Qualifier("zx10001HTMLService")
	private ZXService<ZX10001QueryReports> zxHTMLService;
	@Autowired
	@Qualifier("pbocLoadBasicService")
	private PbocLoadBasicService pbocLoadBasicService;
	@Autowired
	@Qualifier("pbocCreditBasicService")
	private PbocCreditBasicService pbocCreditBasicService;
	@Autowired
	@Qualifier("pbocBadDebtsService")
	private PbocBadDebtsService pbocBadDebtsService;
	@Autowired
	@Qualifier("pbocLoadStatusService")
	private PbocLoadStatusService pbocLoadStatusService;
	@Autowired
	@Qualifier("pbocNearcreditStatusService")
	private PbocNearcreditStatusService pbocNearcreditStatusService;
	@Autowired
	@Qualifier("pbocCreditquerySummaryService")
	private PbocCreditquerySummaryService PbocCreditquerySummaryService;
	@Autowired
	@Qualifier("ruleCallService")
	private RuleCallService ruleService;
	@Autowired
	@Qualifier("nlsProcessRuleService")
	private NlsProcessRuleService nlsProcessRuleService;
	@Autowired
	@Qualifier("prdSoltRuleService")
	private PrdSoltRuleService prdSoltRuleService;
	@Autowired
	@Qualifier("nlsProcessBizService")
	private NlsProcessBizService nlsProcessBizService;
	@Autowired
	@Qualifier("zxHtmlInfoService")
	private ZXHtmlInfoService zxHtmlInfoService;
	@Autowired	
	@Qualifier("pbocCreditStatusService")
	private PbocCreditStatusService pbocCreditStatusService;
	@Autowired	
	@Qualifier("queryReportService")
	private QueryReportService queryReportService;
	@Autowired
	@Qualifier("prdInfoService")
	private PrdInfoService prdInfoService;
}
